//auto gen by paipai.java.augogen ver 3.0.0
//author skyzhuang
//source idl: com.erp.employee.dao.idl.GetEmployeeByIdReq.java


#ifndef ERP_EMPLOYEE_DDO_CEMPLOYEEFILTERDDO_BY_AUTOGEN_V5_H
#define ERP_EMPLOYEE_DDO_CEMPLOYEEFILTERDDO_BY_AUTOGEN_V5_H


#include "app_platform/intf_serializable.h"
#include <set>
#include <bitset>
#include <map>
#include <string>
#include <sstream>
#include <iostream>


namespace erp
{
namespace employee
{
namespace ddo
{


class CEmployeeFilterDdo : public ISerializable
{
	public:
		std::string m_sLastErrMsg;///<错误信息

		/**
		 *  版本号   
		 *
		 * 版本 >= 0
		 */
		uint32_t dwVersion;

		/**
		 * cVersion_u uflag field
		 */
		uint8_t cVersion_u; //optional flag

		/**
		 *  页码，从0开始 
		 *
		 * 版本 >= 0
		 */
		uint32_t dwPage;

		/**
		 * cPage_u uflag field
		 */
		uint8_t cPage_u; //optional flag

		/**
		 *  页面大小 
		 *
		 * 版本 >= 0
		 */
		uint32_t dwPageSize;

		/**
		 * cPageSize_u uflag field
		 */
		uint8_t cPageSize_u; //optional flag

		/**
		 *  排序方式 
		 *
		 * 版本 >= 0
		 */
		uint16_t wOrderType;

		/**
		 * cOrderType_u uflag field
		 */
		uint8_t cOrderType_u; //optional flag

		/**
		 * Id列表，若填写则其他过滤条件无效
		 *
		 * 版本 >= 0
		 */
		std::set<uint32_t>  setIdList;

		/**
		 * cIdList_u uflag field
		 */
		uint8_t cIdList_u; //optional flag

		/**
		 *  员工姓名 
		 *
		 * 版本 >= 0
		 */
		std::string strEmployeeName;

		/**
		 * cEmployeeName_u uflag field
		 */
		uint8_t cEmployeeName_u; //optional flag

		/**
		 *  员工英文名 
		 *
		 * 版本 >= 0
		 */
		std::string strEmployeeEnglishName;

		/**
		 * cEmployeeEnglishName_u uflag field
		 */
		uint8_t cEmployeeEnglishName_u; //optional flag

		/**
		 *  员工状态
		 *
		 * 版本 >= 0
		 */
		std::set<uint16_t>  setEmployeeStatus;

		/**
		 * cEmployeeStatus_u uflag field
		 */
		uint8_t cEmployeeStatus_u; //optional flag

		/**
		 *  员工属性 
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetEmployeePropertyInclude;

		/**
		 * cEmployeePropertyInclude_u uflag field
		 */
		uint8_t cEmployeePropertyInclude_u; //optional flag

		/**
		 *  员工属性，且关系 
		 *
		 * 版本 >= 0
		 */
		std::bitset<32>  bitsetEmployeePropertyExclude;

		/**
		 * cEmployeePropertyExclude_u uflag field
		 */
		uint8_t cEmployeePropertyExclude_u; //optional flag

		/**
		 *  员工属性选项：0：employeePropertyInclude是且的关系；1，employeePropertyInclude是或的关系
		 *
		 * 版本 >= 0
		 */
		uint16_t wEmployeePropertyOption;

		/**
		 * cEmployeePropertyOption_u uflag field
		 */
		uint8_t cEmployeePropertyOption_u; //optional flag

		/**
		 *  添加时间，上限
		 *
		 * 版本 >= 0
		 */
		uint32_t dwAddTimeBegin;

		/**
		 * cAddTimeBegin_u uflag field
		 */
		uint8_t cAddTimeBegin_u; //optional flag

		/**
		 *  添加时间，下限
		 *
		 * 版本 >= 0
		 */
		uint32_t dwAddTimeEnd;

		/**
		 * cAddTimeEnd_u uflag field
		 */
		uint8_t cAddTimeEnd_u; //optional flag

		/**
		 *  扩展
		 *
		 * 版本 >= 0
		 */
		std::map<std::string,std::string>  mapExtern;

		/**
		 * cExtern_u uflag field
		 */
		uint8_t cExtern_u; //optional flag




	public:
		CEmployeeFilterDdo():
		dwVersion(0),
		cVersion_u(0),
		dwPage(0),
		cPage_u(0),
		dwPageSize(0),
		cPageSize_u(0),
		wOrderType(0),
		cOrderType_u(0),
		cIdList_u(0),
		cEmployeeName_u(0),
		cEmployeeEnglishName_u(0),
		cEmployeeStatus_u(0),
		cEmployeePropertyInclude_u(0),
		cEmployeePropertyExclude_u(0),
		wEmployeePropertyOption(0),
		cEmployeePropertyOption_u(0),
		dwAddTimeBegin(0),
		cAddTimeBegin_u(0),
		dwAddTimeEnd(0),
		cAddTimeEnd_u(0),
		cExtern_u(0) {}
				CEmployeeFilterDdo& operator = (const CEmployeeFilterDdo& obj){

			this->dwVersion = obj.dwVersion;
			this->dwPage = obj.dwPage;
			this->dwPageSize = obj.dwPageSize;
			this->wOrderType = obj.wOrderType;
			this->setIdList = obj.setIdList;
			this->strEmployeeName = obj.strEmployeeName;
			this->strEmployeeEnglishName = obj.strEmployeeEnglishName;
			this->setEmployeeStatus = obj.setEmployeeStatus;
			this->bitsetEmployeePropertyInclude = obj.bitsetEmployeePropertyInclude;
			this->bitsetEmployeePropertyExclude = obj.bitsetEmployeePropertyExclude;
			this->wEmployeePropertyOption = obj.wEmployeePropertyOption;
			this->dwAddTimeBegin = obj.dwAddTimeBegin;
			this->dwAddTimeEnd = obj.dwAddTimeEnd;
			this->mapExtern = obj.mapExtern;
			this->cVersion_u = obj.cVersion_u;
			this->cPage_u = obj.cPage_u;
			this->cPageSize_u = obj.cPageSize_u;
			this->cOrderType_u = obj.cOrderType_u;
			this->cIdList_u = obj.cIdList_u;
			this->cEmployeeName_u = obj.cEmployeeName_u;
			this->cEmployeeEnglishName_u = obj.cEmployeeEnglishName_u;
			this->cEmployeeStatus_u = obj.cEmployeeStatus_u;
			this->cEmployeePropertyInclude_u = obj.cEmployeePropertyInclude_u;
			this->cEmployeePropertyExclude_u = obj.cEmployeePropertyExclude_u;
			this->cEmployeePropertyOption_u = obj.cEmployeePropertyOption_u;
			this->cAddTimeBegin_u = obj.cAddTimeBegin_u;
			this->cAddTimeEnd_u = obj.cAddTimeEnd_u;
			this->cExtern_u = obj.cExtern_u;
			return *this;
		}

	public:


		/**
		 * 是否设置 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 bool  IsVersionSet() const{
				 return  cVersion_u != 0;
		}


		/**
		 * 获取uflag 版本号   了
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 const uint8_t   GetVersionUFlag() const{
				 return  cVersion_u;
		}


		/**
		 * 设置 版本号   
		 * 
		 * @param uint32_t:dwVersion
		 *  
		 * 
		 */
		 void  SetVersion( const uint32_t& sVal, uint8_t cUFlag=1){
				dwVersion = sVal;
				cVersion_u = cUFlag;
		}


		/**
		 * 获取 版本号   
		 * 
		 * @return dwVersion value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetVersion() const {
				return dwVersion;
		}


		/**
		 * 是否设置 页码，从0开始 了
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 bool  IsPageSet() const{
				 return  cPage_u != 0;
		}


		/**
		 * 获取uflag 页码，从0开始 了
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 const uint8_t   GetPageUFlag() const{
				 return  cPage_u;
		}


		/**
		 * 设置 页码，从0开始 
		 * 
		 * @param uint32_t:dwPage
		 *  
		 * 
		 */
		 void  SetPage( const uint32_t& sVal, uint8_t cUFlag=1){
				dwPage = sVal;
				cPage_u = cUFlag;
		}


		/**
		 * 获取 页码，从0开始 
		 * 
		 * @return dwPage value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetPage() const {
				return dwPage;
		}


		/**
		 * 是否设置 页面大小 了
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 bool  IsPageSizeSet() const{
				 return  cPageSize_u != 0;
		}


		/**
		 * 获取uflag 页面大小 了
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 const uint8_t   GetPageSizeUFlag() const{
				 return  cPageSize_u;
		}


		/**
		 * 设置 页面大小 
		 * 
		 * @param uint32_t:dwPageSize
		 *  
		 * 
		 */
		 void  SetPageSize( const uint32_t& sVal, uint8_t cUFlag=1){
				dwPageSize = sVal;
				cPageSize_u = cUFlag;
		}


		/**
		 * 获取 页面大小 
		 * 
		 * @return dwPageSize value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetPageSize() const {
				return dwPageSize;
		}


		/**
		 * 是否设置 排序方式 了
		 * 
		 * @param uint16_t:wOrderType
		 *  
		 * 
		 */
		 bool  IsOrderTypeSet() const{
				 return  cOrderType_u != 0;
		}


		/**
		 * 获取uflag 排序方式 了
		 * 
		 * @param uint16_t:wOrderType
		 *  
		 * 
		 */
		 const uint8_t   GetOrderTypeUFlag() const{
				 return  cOrderType_u;
		}


		/**
		 * 设置 排序方式 
		 * 
		 * @param uint16_t:wOrderType
		 *  
		 * 
		 */
		 void  SetOrderType( const uint16_t& sVal, uint8_t cUFlag=1){
				wOrderType = sVal;
				cOrderType_u = cUFlag;
		}


		/**
		 * 获取 排序方式 
		 * 
		 * @return wOrderType value 类型为:uint16_t
		 * 
		 */
		 const uint16_t&  GetOrderType() const {
				return wOrderType;
		}


		/**
		 * 是否设置Id列表，若填写则其他过滤条件无效了
		 * 
		 * @param std::set<uint32_t> :setIdList
		 *  
		 * 
		 */
		 bool  IsIdListSet() const{
				 return  cIdList_u != 0;
		}


		/**
		 * 获取uflagId列表，若填写则其他过滤条件无效了
		 * 
		 * @param std::set<uint32_t> :setIdList
		 *  
		 * 
		 */
		 const uint8_t   GetIdListUFlag() const{
				 return  cIdList_u;
		}


		/**
		 * 设置Id列表，若填写则其他过滤条件无效
		 * 
		 * @param std::set<uint32_t> :setIdList
		 *  
		 * 
		 */
		 void  SetIdList( const std::set<uint32_t> & sVal, uint8_t cUFlag=1){
				setIdList = sVal;
				cIdList_u = cUFlag;
		}


		/**
		 * 获取Id列表，若填写则其他过滤条件无效
		 * 
		 * @return setIdList value 类型为:std::set<uint32_t> 
		 * 
		 */
		 const std::set<uint32_t> &  GetIdList() const {
				return setIdList;
		}


		/**
		 * 获取Id列表，若填写则其他过滤条件无效
		 * 
		 * @return setIdList value 类型为:std::set<uint32_t> 
		 * 
		 */
		 std::set<uint32_t> &  GetIdList() {
				return setIdList;
		}


		/**
		 * 是否设置 员工姓名 了
		 * 
		 * @param std::string:strEmployeeName
		 *  
		 * 
		 */
		 bool  IsEmployeeNameSet() const{
				 return  cEmployeeName_u != 0;
		}


		/**
		 * 获取uflag 员工姓名 了
		 * 
		 * @param std::string:strEmployeeName
		 *  
		 * 
		 */
		 const uint8_t   GetEmployeeNameUFlag() const{
				 return  cEmployeeName_u;
		}


		/**
		 * 设置 员工姓名 
		 * 
		 * @param std::string:strEmployeeName
		 *  
		 * 
		 */
		 void  SetEmployeeName( const std::string& sVal, uint8_t cUFlag=1){
				strEmployeeName = sVal;
				cEmployeeName_u = cUFlag;
		}


		/**
		 * 获取 员工姓名 
		 * 
		 * @return strEmployeeName value 类型为:std::string
		 * 
		 */
		 const std::string&  GetEmployeeName() const {
				return strEmployeeName;
		}


		/**
		 * 获取 员工姓名 
		 * 
		 * @return strEmployeeName value 类型为:std::string
		 * 
		 */
		 std::string&  GetEmployeeName() {
				return strEmployeeName;
		}


		/**
		 * 是否设置 员工英文名 了
		 * 
		 * @param std::string:strEmployeeEnglishName
		 *  
		 * 
		 */
		 bool  IsEmployeeEnglishNameSet() const{
				 return  cEmployeeEnglishName_u != 0;
		}


		/**
		 * 获取uflag 员工英文名 了
		 * 
		 * @param std::string:strEmployeeEnglishName
		 *  
		 * 
		 */
		 const uint8_t   GetEmployeeEnglishNameUFlag() const{
				 return  cEmployeeEnglishName_u;
		}


		/**
		 * 设置 员工英文名 
		 * 
		 * @param std::string:strEmployeeEnglishName
		 *  
		 * 
		 */
		 void  SetEmployeeEnglishName( const std::string& sVal, uint8_t cUFlag=1){
				strEmployeeEnglishName = sVal;
				cEmployeeEnglishName_u = cUFlag;
		}


		/**
		 * 获取 员工英文名 
		 * 
		 * @return strEmployeeEnglishName value 类型为:std::string
		 * 
		 */
		 const std::string&  GetEmployeeEnglishName() const {
				return strEmployeeEnglishName;
		}


		/**
		 * 获取 员工英文名 
		 * 
		 * @return strEmployeeEnglishName value 类型为:std::string
		 * 
		 */
		 std::string&  GetEmployeeEnglishName() {
				return strEmployeeEnglishName;
		}


		/**
		 * 是否设置 员工状态了
		 * 
		 * @param std::set<uint16_t> :setEmployeeStatus
		 *  
		 * 
		 */
		 bool  IsEmployeeStatusSet() const{
				 return  cEmployeeStatus_u != 0;
		}


		/**
		 * 获取uflag 员工状态了
		 * 
		 * @param std::set<uint16_t> :setEmployeeStatus
		 *  
		 * 
		 */
		 const uint8_t   GetEmployeeStatusUFlag() const{
				 return  cEmployeeStatus_u;
		}


		/**
		 * 设置 员工状态
		 * 
		 * @param std::set<uint16_t> :setEmployeeStatus
		 *  
		 * 
		 */
		 void  SetEmployeeStatus( const std::set<uint16_t> & sVal, uint8_t cUFlag=1){
				setEmployeeStatus = sVal;
				cEmployeeStatus_u = cUFlag;
		}


		/**
		 * 获取 员工状态
		 * 
		 * @return setEmployeeStatus value 类型为:std::set<uint16_t> 
		 * 
		 */
		 const std::set<uint16_t> &  GetEmployeeStatus() const {
				return setEmployeeStatus;
		}


		/**
		 * 获取 员工状态
		 * 
		 * @return setEmployeeStatus value 类型为:std::set<uint16_t> 
		 * 
		 */
		 std::set<uint16_t> &  GetEmployeeStatus() {
				return setEmployeeStatus;
		}


		/**
		 * 是否设置 员工属性 了
		 * 
		 * @param std::bitset<32> :bitsetEmployeePropertyInclude
		 *  
		 * 
		 */
		 bool  IsEmployeePropertyIncludeSet() const{
				 return  cEmployeePropertyInclude_u != 0;
		}


		/**
		 * 获取uflag 员工属性 了
		 * 
		 * @param std::bitset<32> :bitsetEmployeePropertyInclude
		 *  
		 * 
		 */
		 const uint8_t   GetEmployeePropertyIncludeUFlag() const{
				 return  cEmployeePropertyInclude_u;
		}


		/**
		 * 设置 员工属性 
		 * 
		 * @param std::bitset<32> :bitsetEmployeePropertyInclude
		 *  
		 * 
		 */
		 void  SetEmployeePropertyInclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetEmployeePropertyInclude = sVal;
				cEmployeePropertyInclude_u = cUFlag;
		}


		/**
		 * 获取 员工属性 
		 * 
		 * @return bitsetEmployeePropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetEmployeePropertyInclude() const {
				return bitsetEmployeePropertyInclude;
		}


		/**
		 * 获取 员工属性 
		 * 
		 * @return bitsetEmployeePropertyInclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetEmployeePropertyInclude() {
				return bitsetEmployeePropertyInclude;
		}


		/**
		 * 是否设置 员工属性，且关系 了
		 * 
		 * @param std::bitset<32> :bitsetEmployeePropertyExclude
		 *  
		 * 
		 */
		 bool  IsEmployeePropertyExcludeSet() const{
				 return  cEmployeePropertyExclude_u != 0;
		}


		/**
		 * 获取uflag 员工属性，且关系 了
		 * 
		 * @param std::bitset<32> :bitsetEmployeePropertyExclude
		 *  
		 * 
		 */
		 const uint8_t   GetEmployeePropertyExcludeUFlag() const{
				 return  cEmployeePropertyExclude_u;
		}


		/**
		 * 设置 员工属性，且关系 
		 * 
		 * @param std::bitset<32> :bitsetEmployeePropertyExclude
		 *  
		 * 
		 */
		 void  SetEmployeePropertyExclude( const std::bitset<32> & sVal, uint8_t cUFlag=1){
				bitsetEmployeePropertyExclude = sVal;
				cEmployeePropertyExclude_u = cUFlag;
		}


		/**
		 * 获取 员工属性，且关系 
		 * 
		 * @return bitsetEmployeePropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 const std::bitset<32> &  GetEmployeePropertyExclude() const {
				return bitsetEmployeePropertyExclude;
		}


		/**
		 * 获取 员工属性，且关系 
		 * 
		 * @return bitsetEmployeePropertyExclude value 类型为:std::bitset<32> 
		 * 
		 */
		 std::bitset<32> &  GetEmployeePropertyExclude() {
				return bitsetEmployeePropertyExclude;
		}


		/**
		 * 是否设置 员工属性选项：0：employeePropertyInclude是且的关系；1，employeePropertyInclude是或的关系了
		 * 
		 * @param uint16_t:wEmployeePropertyOption
		 *  
		 * 
		 */
		 bool  IsEmployeePropertyOptionSet() const{
				 return  cEmployeePropertyOption_u != 0;
		}


		/**
		 * 获取uflag 员工属性选项：0：employeePropertyInclude是且的关系；1，employeePropertyInclude是或的关系了
		 * 
		 * @param uint16_t:wEmployeePropertyOption
		 *  
		 * 
		 */
		 const uint8_t   GetEmployeePropertyOptionUFlag() const{
				 return  cEmployeePropertyOption_u;
		}


		/**
		 * 设置 员工属性选项：0：employeePropertyInclude是且的关系；1，employeePropertyInclude是或的关系
		 * 
		 * @param uint16_t:wEmployeePropertyOption
		 *  
		 * 
		 */
		 void  SetEmployeePropertyOption( const uint16_t& sVal, uint8_t cUFlag=1){
				wEmployeePropertyOption = sVal;
				cEmployeePropertyOption_u = cUFlag;
		}


		/**
		 * 获取 员工属性选项：0：employeePropertyInclude是且的关系；1，employeePropertyInclude是或的关系
		 * 
		 * @return wEmployeePropertyOption value 类型为:uint16_t
		 * 
		 */
		 const uint16_t&  GetEmployeePropertyOption() const {
				return wEmployeePropertyOption;
		}


		/**
		 * 是否设置 添加时间，上限了
		 * 
		 * @param uint32_t:dwAddTimeBegin
		 *  
		 * 
		 */
		 bool  IsAddTimeBeginSet() const{
				 return  cAddTimeBegin_u != 0;
		}


		/**
		 * 获取uflag 添加时间，上限了
		 * 
		 * @param uint32_t:dwAddTimeBegin
		 *  
		 * 
		 */
		 const uint8_t   GetAddTimeBeginUFlag() const{
				 return  cAddTimeBegin_u;
		}


		/**
		 * 设置 添加时间，上限
		 * 
		 * @param uint32_t:dwAddTimeBegin
		 *  
		 * 
		 */
		 void  SetAddTimeBegin( const uint32_t& sVal, uint8_t cUFlag=1){
				dwAddTimeBegin = sVal;
				cAddTimeBegin_u = cUFlag;
		}


		/**
		 * 获取 添加时间，上限
		 * 
		 * @return dwAddTimeBegin value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetAddTimeBegin() const {
				return dwAddTimeBegin;
		}


		/**
		 * 是否设置 添加时间，下限了
		 * 
		 * @param uint32_t:dwAddTimeEnd
		 *  
		 * 
		 */
		 bool  IsAddTimeEndSet() const{
				 return  cAddTimeEnd_u != 0;
		}


		/**
		 * 获取uflag 添加时间，下限了
		 * 
		 * @param uint32_t:dwAddTimeEnd
		 *  
		 * 
		 */
		 const uint8_t   GetAddTimeEndUFlag() const{
				 return  cAddTimeEnd_u;
		}


		/**
		 * 设置 添加时间，下限
		 * 
		 * @param uint32_t:dwAddTimeEnd
		 *  
		 * 
		 */
		 void  SetAddTimeEnd( const uint32_t& sVal, uint8_t cUFlag=1){
				dwAddTimeEnd = sVal;
				cAddTimeEnd_u = cUFlag;
		}


		/**
		 * 获取 添加时间，下限
		 * 
		 * @return dwAddTimeEnd value 类型为:uint32_t
		 * 
		 */
		 const uint32_t&  GetAddTimeEnd() const {
				return dwAddTimeEnd;
		}


		/**
		 * 是否设置 扩展了
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 bool  IsExternSet() const{
				 return  cExtern_u != 0;
		}


		/**
		 * 获取uflag 扩展了
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 const uint8_t   GetExternUFlag() const{
				 return  cExtern_u;
		}


		/**
		 * 设置 扩展
		 * 
		 * @param std::map<std::string,std::string> :mapExtern
		 *  
		 * 
		 */
		 void  SetExtern( const std::map<std::string,std::string> & sVal, uint8_t cUFlag=1){
				mapExtern = sVal;
				cExtern_u = cUFlag;
		}


		/**
		 * 获取 扩展
		 * 
		 * @return mapExtern value 类型为:std::map<std::string,std::string> 
		 * 
		 */
		 const std::map<std::string,std::string> &  GetExtern() const {
				return mapExtern;
		}


		/**
		 * 获取 扩展
		 * 
		 * @return mapExtern value 类型为:std::map<std::string,std::string> 
		 * 
		 */
		 std::map<std::string,std::string> &  GetExtern() {
				return mapExtern;
		}

		virtual bool Serialize(CByteStreamNetwork& bs){
		
			uint32_t dwMyLen = 0;
			if(bs.isStoring()) //for write in buffer
			{
				//can not larger than 1 M.
				CByteStreamNetwork bsDummy(NULL, 1024 * 1024, false);
				//bsDummy for precheck the xo size...
				bsDummy.isStoring(true);
				Serialize_i(bsDummy);
				dwMyLen = bsDummy.getWrittenLength();
				bs & dwMyLen;
				Serialize_i(bs);
			}
			else
			{    //for read from buffer
				bs & dwMyLen;
				uint32_t dwReadedLen = bs.getReadLength();
				Serialize_i(bs);
				dwReadedLen = bs.getReadLength() - dwReadedLen;
				// dwReadedLen for the size of xo
				if( dwReadedLen > dwMyLen ){
					return false;
				}
				//go through the unwanted mem position...
				bs.goForward( dwMyLen - dwReadedLen );
			}

			return bs.isGood();
		}

		bool Serialize_i(CByteStreamNetwork& bsTmp){

			bsTmp & dwVersion; // 序列化 版本号    类型为uint32_t
			bsTmp & cVersion_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwPage; // 序列化 页码，从0开始  类型为uint32_t
			bsTmp & cPage_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwPageSize; // 序列化 页面大小  类型为uint32_t
			bsTmp & cPageSize_u; // 序列化uflag 类型为uint8_t
			bsTmp & wOrderType; // 序列化 排序方式  类型为uint16_t
			bsTmp & cOrderType_u; // 序列化uflag 类型为uint8_t
			bsTmp & setIdList; // 序列化Id列表，若填写则其他过滤条件无效 类型为Set
			bsTmp & cIdList_u; // 序列化uflag 类型为uint8_t
			bsTmp & strEmployeeName; // 序列化 员工姓名  类型为String
			bsTmp & cEmployeeName_u; // 序列化uflag 类型为uint8_t
			bsTmp & strEmployeeEnglishName; // 序列化 员工英文名  类型为String
			bsTmp & cEmployeeEnglishName_u; // 序列化uflag 类型为uint8_t
			bsTmp & setEmployeeStatus; // 序列化 员工状态 类型为Set
			bsTmp & cEmployeeStatus_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetEmployeePropertyInclude; // 序列化 员工属性  类型为BitSet
			bsTmp & cEmployeePropertyInclude_u; // 序列化uflag 类型为uint8_t
			bsTmp & bitsetEmployeePropertyExclude; // 序列化 员工属性，且关系  类型为BitSet
			bsTmp & cEmployeePropertyExclude_u; // 序列化uflag 类型为uint8_t
			bsTmp & wEmployeePropertyOption; // 序列化 员工属性选项：0：employeePropertyInclude是且的关系；1，employeePropertyInclude是或的关系 类型为uint16_t
			bsTmp & cEmployeePropertyOption_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwAddTimeBegin; // 序列化 添加时间，上限 类型为uint32_t
			bsTmp & cAddTimeBegin_u; // 序列化uflag 类型为uint8_t
			bsTmp & dwAddTimeEnd; // 序列化 添加时间，下限 类型为uint32_t
			bsTmp & cAddTimeEnd_u; // 序列化uflag 类型为uint8_t
			bsTmp & mapExtern; // 序列化 扩展 类型为Map
			bsTmp & cExtern_u; // 序列化uflag 类型为uint8_t
			return bsTmp.isGood();
		}

		const char* GetLastErrMsg() const{
			return m_sLastErrMsg.c_str();
		}

		bool VerifyEmployeeFilterDdo(){

			if(!IsVersionSet()){
				m_sLastErrMsg = "Miss Param:version";
				return false;
			}

			if(!IsPageSet()){
				m_sLastErrMsg = "Miss Param:page";
				return false;
			}

			if(!IsPageSizeSet()){
				m_sLastErrMsg = "Miss Param:pageSize";
				return false;
			}

			if(!IsOrderTypeSet()){
				m_sLastErrMsg = "Miss Param:orderType";
				return false;
			}

			if(!IsIdListSet()){
				m_sLastErrMsg = "Miss Param:idList";
				return false;
			}

			if(!IsEmployeeNameSet()){
				m_sLastErrMsg = "Miss Param:employeeName";
				return false;
			}

			if(!IsEmployeeEnglishNameSet()){
				m_sLastErrMsg = "Miss Param:employeeEnglishName";
				return false;
			}

			if(!IsEmployeeStatusSet()){
				m_sLastErrMsg = "Miss Param:employeeStatus";
				return false;
			}

			if(!IsEmployeePropertyIncludeSet()){
				m_sLastErrMsg = "Miss Param:employeePropertyInclude";
				return false;
			}

			if(!IsEmployeePropertyExcludeSet()){
				m_sLastErrMsg = "Miss Param:employeePropertyExclude";
				return false;
			}

			if(!IsEmployeePropertyOptionSet()){
				m_sLastErrMsg = "Miss Param:employeePropertyOption";
				return false;
			}

			if(!IsAddTimeBeginSet()){
				m_sLastErrMsg = "Miss Param:addTimeBegin";
				return false;
			}

			if(!IsAddTimeEndSet()){
				m_sLastErrMsg = "Miss Param:addTimeEnd";
				return false;
			}

			if(!IsExternSet()){
				m_sLastErrMsg = "Miss Param:extern";
				return false;
			}
			return true;
		}

		void DumpData(std::ostream& oss) const{
		
			oss<<"[dwVersion:"<<dwVersion<<"] ";
			oss<<"[cVersion_u:"<<(int)cVersion_u<<"] ";
			oss<<"[dwPage:"<<dwPage<<"] ";
			oss<<"[cPage_u:"<<(int)cPage_u<<"] ";
			oss<<"[dwPageSize:"<<dwPageSize<<"] ";
			oss<<"[cPageSize_u:"<<(int)cPageSize_u<<"] ";
			oss<<"[wOrderType:"<<(int)wOrderType<<"] ";
			oss<<"[cOrderType_u:"<<(int)cOrderType_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cIdList_u:"<<(int)cIdList_u<<"] ";
			oss<<"[strEmployeeName:"<<strEmployeeName<<"] ";
			oss<<"[cEmployeeName_u:"<<(int)cEmployeeName_u<<"] ";
			oss<<"[strEmployeeEnglishName:"<<strEmployeeEnglishName<<"] ";
			oss<<"[cEmployeeEnglishName_u:"<<(int)cEmployeeEnglishName_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cEmployeeStatus_u:"<<(int)cEmployeeStatus_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cEmployeePropertyInclude_u:"<<(int)cEmployeePropertyInclude_u<<"] ";
		//嵌套内容有错误，建议使用dumpDataTree方法，复杂数据格式更直观！
			oss<<"[cEmployeePropertyExclude_u:"<<(int)cEmployeePropertyExclude_u<<"] ";
			oss<<"[wEmployeePropertyOption:"<<(int)wEmployeePropertyOption<<"] ";
			oss<<"[cEmployeePropertyOption_u:"<<(int)cEmployeePropertyOption_u<<"] ";
			oss<<"[dwAddTimeBegin:"<<dwAddTimeBegin<<"] ";
			oss<<"[cAddTimeBegin_u:"<<(int)cAddTimeBegin_u<<"] ";
			oss<<"[dwAddTimeEnd:"<<dwAddTimeEnd<<"] ";
			oss<<"[cAddTimeEnd_u:"<<(int)cAddTimeEnd_u<<"] ";

			std::map<std::string,std::string>::const_iterator itmapExtern=mapExtern.begin();
			std::map<std::string,std::string>::const_iterator itmapExternEnd=mapExtern.end();
			for(;itmapExtern!=itmapExternEnd;itmapExtern++)
				oss<<"[mapExtern:"<<itmapExtern->second<<"] ";
			oss<<"[cExtern_u:"<<(int)cExtern_u<<"] ";
		
		}

		// codydeng提供,非常好的dump方法 ^-^  。。。。。
		template<typename T>
		T & DumpPlusData(T& oss){
			oss<<"dwVersion:"<<dwVersion;
			oss<<"[cVersion_u:"<<cVersion_u<<"] ";
			oss<<"dwPage:"<<dwPage;
			oss<<"[cPage_u:"<<cPage_u<<"] ";
			oss<<"dwPageSize:"<<dwPageSize;
			oss<<"[cPageSize_u:"<<cPageSize_u<<"] ";
			oss<<"wOrderType:"<<wOrderType;
			oss<<"[cOrderType_u:"<<cOrderType_u<<"] ";
			oss<<"setIdList:"<<setIdList;
			oss<<"[cIdList_u:"<<cIdList_u<<"] ";
			oss<<"strEmployeeName:"<<strEmployeeName;
			oss<<"[cEmployeeName_u:"<<cEmployeeName_u<<"] ";
			oss<<"strEmployeeEnglishName:"<<strEmployeeEnglishName;
			oss<<"[cEmployeeEnglishName_u:"<<cEmployeeEnglishName_u<<"] ";
			oss<<"setEmployeeStatus:"<<setEmployeeStatus;
			oss<<"[cEmployeeStatus_u:"<<cEmployeeStatus_u<<"] ";
			oss<<"bitsetEmployeePropertyInclude:"<<bitsetEmployeePropertyInclude;
			oss<<"[cEmployeePropertyInclude_u:"<<cEmployeePropertyInclude_u<<"] ";
			oss<<"bitsetEmployeePropertyExclude:"<<bitsetEmployeePropertyExclude;
			oss<<"[cEmployeePropertyExclude_u:"<<cEmployeePropertyExclude_u<<"] ";
			oss<<"wEmployeePropertyOption:"<<wEmployeePropertyOption;
			oss<<"[cEmployeePropertyOption_u:"<<cEmployeePropertyOption_u<<"] ";
			oss<<"dwAddTimeBegin:"<<dwAddTimeBegin;
			oss<<"[cAddTimeBegin_u:"<<cAddTimeBegin_u<<"] ";
			oss<<"dwAddTimeEnd:"<<dwAddTimeEnd;
			oss<<"[cAddTimeEnd_u:"<<cAddTimeEnd_u<<"] ";
			oss<<"mapExtern:"<<mapExtern;
			oss<<"[cExtern_u:"<<cExtern_u<<"] ";
			return oss;
		}

		// wileywang提供,树形dump方法 ^-^  。。。。。
		void DumpDataTree(std::ostream& os, int ident = 0)const {
			g_pprint(os, "dwVersion", dwVersion, ident);
			g_pprint(os, "cVersion_u", cVersion_u, ident);
			g_pprint(os, "dwPage", dwPage, ident);
			g_pprint(os, "cPage_u", cPage_u, ident);
			g_pprint(os, "dwPageSize", dwPageSize, ident);
			g_pprint(os, "cPageSize_u", cPageSize_u, ident);
			g_pprint(os, "wOrderType", wOrderType, ident);
			g_pprint(os, "cOrderType_u", cOrderType_u, ident);
			g_pprint(os, "setIdList", setIdList, ident);
			g_pprint(os, "cIdList_u", cIdList_u, ident);
			g_pprint(os, "strEmployeeName", strEmployeeName, ident);
			g_pprint(os, "cEmployeeName_u", cEmployeeName_u, ident);
			g_pprint(os, "strEmployeeEnglishName", strEmployeeEnglishName, ident);
			g_pprint(os, "cEmployeeEnglishName_u", cEmployeeEnglishName_u, ident);
			g_pprint(os, "setEmployeeStatus", setEmployeeStatus, ident);
			g_pprint(os, "cEmployeeStatus_u", cEmployeeStatus_u, ident);
			g_pprint(os, "bitsetEmployeePropertyInclude", bitsetEmployeePropertyInclude, ident);
			g_pprint(os, "cEmployeePropertyInclude_u", cEmployeePropertyInclude_u, ident);
			g_pprint(os, "bitsetEmployeePropertyExclude", bitsetEmployeePropertyExclude, ident);
			g_pprint(os, "cEmployeePropertyExclude_u", cEmployeePropertyExclude_u, ident);
			g_pprint(os, "wEmployeePropertyOption", wEmployeePropertyOption, ident);
			g_pprint(os, "cEmployeePropertyOption_u", cEmployeePropertyOption_u, ident);
			g_pprint(os, "dwAddTimeBegin", dwAddTimeBegin, ident);
			g_pprint(os, "cAddTimeBegin_u", cAddTimeBegin_u, ident);
			g_pprint(os, "dwAddTimeEnd", dwAddTimeEnd, ident);
			g_pprint(os, "cAddTimeEnd_u", cAddTimeEnd_u, ident);
			g_pprint(os, "mapExtern", mapExtern, ident);
			g_pprint(os, "cExtern_u", cExtern_u, ident);
		}
		
		//提供ToString借口，默认为DumpData格式，请按需要进行修改
		std::string ToString() const{
			std::stringstream ss;
			DumpData(ss);
			return ss.str();
		}

/**
 ********************以下信息是每个版本的字段********************
 */

};

}
}
}

#endif /* ERP_EMPLOYEE_DDO_CEMPLOYEEFILTERDDO_BY_AUTOGEN_V5_H */
